Copyright: (c) Daniel Doubrovkine - Vestris Inc. - University of Geneva - 1994-1998
Citation: (c) Daniel Doubrovkine - Vestris Inc. - University of Geneva - 1994-1998


About the Expression Calculator

Expression Calculator is a powerful mathematical expressions evaluator. It is full 32 bit object oriented and is designed for Windows NT and Windows 95.

Expression Calculator 2.0 has been developed with (c) Borland Delphi 2.0 under Windows NT (TM).

the Expression Calculator is dedicated to the genius of a Swiss mathematician - Leonhard Euler (Basel 1707 - St-Petersbourg 1783)

Disclaimer: This computer program is protected by copyright law and international treaties. Unauthorized reproduction or distribution of this program, or any portion of it, may result in severe civil and criminal penalties, and will be prosecuted to the maximum extent possible under the law. The author of this software as well as any party involved in the production and the distribution may not be held responsible for any kind of whatsoever may be claimed due directly or indirectly to the use of this product. This is an unregistered shareware version.

What's new in the Expression Calculator!

The Expression Calculator is a genuine software program without any particular basis, all material used has been listed below. The Expression Calculator includes uninherited TreeView32 (v.1.2) & MathCalc32 (v.2.3) ( TThread ) multithread objects (c)  Daniel Doubrovkine (1996). Expression Calculator calculates a huge number of mathematical expressions with a satisfactory precision. Expression Calculator uses advanced numerical methods, but it is not made to concurrence symbolic analysis software like WaterLoo (R) Maple or Wolfram (R) Mathematica. Expression Calculator has a true multithread capability due to it's rigorous object oriented style and it's powerful calculation thread generator.

Latest information about the Expression Calculator can be obtained from the Internet:

main Vestris Inc. site in Switzerland: http://www.vestris.com

University of Geneva little mirror: http://cuiwww.unige.ch/~doubrov5

For bugs, problems, money, decent and serious proposals, please contact (best by e-mail):

Vestris Inc. - Daniel Doubrovkine

25, rue Jean-Violette

1205 Geneva - Switzerland

tél & fax: 41 (0) 22 329 03 06

e-mail: dblock@vestris.com / doubrov5@cuimail.unige.ch

Any kind of notes and support welcome!

books and material directly or indirectly used for writing this cool calculator:

N. Wirth (Eidgenossische Technische Hochschule, Zürich, Switzerland) - "Algorithms + Data Structures = Programs", Izdatel'stvo Mir, Moscow, 1985

R. Sedgewick (University of Princeton) - "Algorithms in C language", InterEditions, Paris, 1991

Bjarne Stroustrup (AT&T Bell Laboratories) - "The C++ Programming Language" (second edition), AT&T Bell Telephone Labs Inc., 1993

E.Hairer - G. Wanner (University of Geneva) - "Analysis by it's History", Springer-Verlag, 1995

Mr. Haussmann (University of Geneva), my algebra course, 1995-96

Ernst Hairer (University of Geneva) - "Analyse Numérique" (second edition), University of Geneva, 1993

M.Abramowitz, I.Stegun, "Handbook of Mathematical Functions.'', Dover Publications Inc., New York, 1965

A. Erdelyi, "Higher Transcendental Functions", McGraw-Hill, 1953

C.Berezinsky, "Accélération de la Convergence en Analyse Numérique", Lecture Notes in Mathematics, Nr. 584, Springer-Verlag, 1977

There're also a few lines of code from the SWAG Pascal support team, which is doing a really great job.

* * *

Special thanks go to my math and numerical analysis teachers at the university of Geneva (Mr. G.Wanner and E.Hairer) - without them this calculator would have never been possible. Many thanks to all my friends who have supported the Expression Calculator, to Infomaniak Megastore (Geneva) team, actually to all those who have participated in this project in a way or another.


Expression Calculator User's Guide

The general idea of the Expression Calculator is that you can write any valid mathematical expression and the program will calculate it for you. You must distinguish several parts of the Expression Calculator:

command line parameters:

small	:	initialize the Expression Calculator in a small size

medium	:	initialize the Expression Calculator in a medium size

scientific	:	initialize the Expression Calculator in a full scientific size

notitle	:	do not show the initialization bitmap

all other parameters will be ignored and when one of the above options omitted, Expression Calculator will start in the latest mode known

the Result Grid:

The Result Grid provides a history for calculation. Clicking with the left mouse button on a cell will copy the expression to the input box for reevaluation. You can copy the corresponding result to the clipboard by clicking on the first column (containing the line numbers) with the left mouse button.

Clicking with the right button on a running task will pop the following menu:

Copy	copy expressions and results to the clipboard

Tasks	interrupt or suspend single and multiple tasks

Primes	clear primes tables, copy primes to clipboard

Save	save calculations into a file

Load	load a previously saved file

Process Clipboard	process all expressions in clipboard

Direct Mode	(registered version only) allows to perform calculation using previous results as with non expression calculators (the new expression must start with an operator)

Reset	reset the expression calculator (= AC button)

Exit	exit the expression calculator (= OFF button)

the Input Box:

The Input Box is used to enter an expression. You may enter any natural expressions the Expression Calculator understands.

the Result Panel:

The Result Panel shows the latest result of an operation. It contains a short rounded and the complete evaluation result. It also contains indicators for the calculation modes. The Result Panel has two arrows to wrap and unwrap the Expression Calculator from a scientific to a less scientific view.

the Modes Panel:

The Modes Panel allows to check the number of tasks running and to switch between the RADient and the DEGree mode. By switching between the DEG/RAD (decimal modes), HEXadecimal, BINary and OCTal mode results and valid input will change consequently.

the Functions' Panel

Divided in two parts, the Functions Panel contains operational flags for inverse, hyperbolic and negative functions:

ARC: 	inverse functions flag (SIN becomes ARCSIN)

HYP: 	hyperbolic functions flag (SIN becomes SINH, with the ARC enabled, SIN becomes ARCSINH)

NOT: 	inverse logical operations, XOR becomes XNOR, etc.

i: 	shows the about Expression Calculator Box

a: 	aborts all running tasks

?: 	shows the help file

The right arrow button pops a menu containing most of the advanced functions of the Expression Calculator including defining user functions.

By pressing any other function button, the corresponding operation will be inserted at the cursor position of the Input Box.

the Operations' Panel

Same as Functions Panel, this later contains the simple operations you may want to perform, as well as the variable support:

STO: 	store a single character variable (prompts a window with available variables)

RCL: 	restore a single character variable (prompts a window with available variables)

ANS: 	the last calculated expression

EXP: 	*10^expression

OFF: 	quit the expression calculator

AC: 	clear all operations

C: 	clear the current input

DEL: 	delete the actual input character

You can easily resize the Expression Calculator. Shape will be kept for the next session using the registry and will be user private. Pressing Space and Alt+Space will show Expression Calculator's menus.

see also: user defined functions, mathematical repository


Mathematical Repository

This repository contains all the functions the Expression Calculator can perform with their mathematical description.

- Constants:

Pi

E (Euler's Number)

G (Euler's constant)

Catalan

True / False

- Operators:

+ (plus)

- (minus)

* (product)

/ (division)

% (percentage)

¦ (integer division)

^ (power)

! (factor)

\ (root)

e

m (modulo)

= (assignment)

? (equality test)

> (greater)

< (smaller)

- Logical Operators:

and

nand

nor

not

or

shl

shr

xnor

xor

- General Functions:

abs

average

ceil

floor

frac

gcd (greatest common divisor)

intg

lcm (least common multiple)

ln / log

logten

logn

max

min

mul

quot

random

rem

round

sum

sqr

sqrt

trunc

- Trigonometric and Hyperbolic:

arccos

arccosh

arccot

arccoth

arccsc

arccsch

arcsec

arcsech

arcsin

arcsinh

arctan

arctanh

cos

cosh

cot

coth

csc

csch

exp

sec

sech

sin

sinh

tan

tanh

- Special Functions and Series:

beta

binom

fib (fibonacci)

fermat

gamma (Euler's Gamma)

harmonic

pochhammer

sigma

tau

- Primes & Numbers:

genmers

isprime

mersienne

mersiennegen

mersgen

moebius / mu

perfect

phi (eInd)

prime

primec

primen / ithprime

safeprime

- Integrals:

- approximations (student)

trapezoid

simpson

newton

boole

ordersix

weddle

- exact (Gauss):

Int

dilog

dawson

Erf - the Error Function

Erfc - the Complementary Error Function and its Iterated Integrals

- trigonometric

Si - the Sine Integral

Ci - the Cosine Integral

Ssi - the Shifted Sine Integral

Shi - the Hyperbolic Sine Integral

Chi - the Hyperbolic Cosine Integral

- Fresnel

Fresnel

FresnelC - the Fresnel Cosine Integral

FresnelS - the Fresnel Sine Integral

Fresnelf, Fresnelg - the Fresnel Auxiliary Functions

- elliptic

EllipticE - Incomplete and complete elliptic integrals of the second kind

EllipticCE - Complementary complete elliptic integral of the second kind

EllipticF - Incomplete elliptic integral of the first kind

EllipticK - Complete elliptic integral of the first kind

EllipticCK - Complementary complete elliptic integral of the first kind

- Plot (registered version only)

plot (2D plot)

zplot (3D plot)

- Financial Functions (registered version only)

sln

syd

cterm

term

pmt

rate

pv

npv

fv

db

ddb

irate

nper

paymt

ppaymt

ipaymt

pval

fval

see also: users guide, defining user functions


plus
+

description:	simple addition

syntax:	x + y

domain:	+ : ( R x R ) -> R

example:	2 + 2 = 4


minus
-

description:	simple subtraction

syntax:	x - y

domain:	- : ( R x R ) -> R

example:	2 - 8 = -6


product
*

description:	simple product

syntax:	x * y

domain:	* : ( R x R ) -> R

example:	2 * 2 = 4


division
/

description:	simple division

syntax:	x / y

domain:	/ : ( R x R* ) -> R

example:	2 / -2 = -1


modula
m

description:	modulo division

syntax:	x m y | x, y legal expressions, y <> 0

domain:	m : ( R x R* ) -> Z

example:	4 m 2 = 0

notes:	you may not combine modulo function with constants directly (to perform a mod b you should write ( a ) m ( b ) to avoid ambiguities)


percentage
%

description:	left percentage of right expression

syntax:	x % y

domain:	% : ( R x R ) -> Z

example:	4 % 2 = 0.08

notes:	percentage  is calculated sign independent, then multiplied by both signs.


integer division, rem, quot
¦

description:	integer division

syntax:	x ¦ y

domain:	¦ : ( R x R* ) -> R

example:	4.1 ¦ 2 = 2

notes:	makes the division, then truncates the value

rem ( x , y )	the remainder of the integer division of x by y

quot ( x , y )	substitution function for integer division


power
^

description:	power, elevates a number into a power

syntax:	x ^ y

domain:	^ : ( R x R ) -> R

example:	4 ^ 3 = 64


factor
!

description:	factor

syntax:	x !

domain:	! : R \ { Z- } -> R

example:	- 2.1! = 9.71

theory:	uses Euler's Gamma function

Step of 0.01 is used for the integral and infinity replaced by a progressive algorithm.

0! is 1 by definition.

plot of the Factorial function (with negative extension):


root
\

description:	root

syntax:	x \ y

domain:	\ : R* -> R

and a pair root cannot be calculated for a negative number

example:	3 \ 8 = 2

notes:	x \ y = y ^ ( 1 / x )


xor

description:	bitwise xor

syntax:	x xor y

domain:	xor : ( Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	2 xor 4 = 6

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is xored:

0	0	0

0	1	1

1	0	1

1	1	0


xnor

description:	bitwise xnor

syntax:	x xnor y

domain:	xnor : ( Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	2 xnor 4 = -8

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is xnored:

0	0	1

0	1	0

1	0	0

1	1	1


and

description:	bitwise and

syntax:	x and y

x & y

domain:	and : ( Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	3 and 9 = 1

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is anded:

0	0	0

0	1	0

1	0	0

1	1	1


nand

description:	nand

syntax:	x nand y

domain:	nand : Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	3 nand 9 = 1

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is nanded:

0	0	1

0	1	1

1	0	1

1	1	0


or

description:	or

syntax:	x or y

domain:	or : ( Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	2 or 4 = 6

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is ored:

0	0	0

0	1	1

1	0	1

1	1	1


nor

description:	nor

syntax:	x nor y

domain:	nor : ( Z ( trunc ( R ) ) x Z ( trunc ( R ) ) ) -> Z

example:	2 nor 4 = -7

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is nored:

0	0	1

0	1	0

1	0	0

1	1	0


Not

description:	bitwise Not

syntax:	Not ( x )

domain:	Not : Z ( trunc ( R ) ) -> Z

example:	Not ( 1 ) = 2

notes:	if the values of expressions for x and y are not integer, they are truncated

each bit is inverted:

0	1

1	0


Lcm

description:	Least Common Multiple between up to as many arguments as required

syntax:	Lcm ( x , ... , y )

domain:	Lcm : ( Z x Z ) -> Z

example:	Lcm ( 14 , 4 ) =28

notes:	Lcm ( u , v ) := ( u ¦ gcd ( u , v ) ) * v )


Gcd

description:	Greatest Common Divisor between up to as many arguments as wanted

syntax:	Gcd ( x , ... , y )

domain:	Gcd : ( Z x Z ) -> Z

example:	Gcd ( 3213 , 24 ) =3

notes:	there's a very simple Euclide's algorithm to find the greatest common divisor between two integers:

t: of x , y type;

while ( x <> 0 ) do begin

t := x - trunc ( x / y ) * y;	// t := x mod y

x := y;

y := t;

end;

gcd := x;


fibonacci
Fib

description:	Fibonacci integers

syntax:	Fib ( x )

domain:	Fib : N -> N

example:	Fib ( 56 ) = 2.258e11

notes:	Fibonacci is defined this way:

Fib ( x < 2 ) := x

Fib ( x ) := Fib( x - 1 ) + Fib( x - 2 )

The current function uses a super fast iterative matrix method and is able to calculate Fibonacci numbers up to fib ( 2^14 ).


Gamma

description:	Euler's Gamma function (or simply Euler's function)

syntax:	Gamma ( x , step )

domain:	Gamma : ( R \ Z_ x R ) -> R

example:	Gamma ( 0.5, 0.001 ) = 1.77244070463831

theory:	For positive values

and is extended to negative values with

For negative values this is just a definition and the integral has here absolutely no sense.

Gamma ( 1/2 ) = Sqrt ( Pi ). This function diverges for integer negative values.

Check the factorial and Euler's beta functions for a concrete use of the gamma function.


shl

description:	bitwise shift left

syntax:	Shl ( x , y )

domain:	Shl : ( Z x Z ) -> Z

example:	Shl ( 2 , 1 ) = 4

notes:	shifts the values of x left of y positions, same as multiplying by 2 ^ y


shr

description:	bitwise shift right

syntax:	Shr ( x , y )

domain:	Shr : ( Z x Z ) -> Z

example:	Shr ( 2 , 1 ) = 1

notes:	shifts the values of x right of y positions, same as dividing by 2 ^ y


Min

description:	chooses the smallest value between up to as many arguments as wanted

syntax:	Min ( x , ... , y )

domain:	Min : ( R x R ) -> R

example:	Min ( 1 , 2 ) = 1


Max

description:	chooses the biggest value between up to as many arguments as wanted

syntax:	Max ( x , ... , y )

domain:	Max : ( R x R ) -> R

example:	Max ( 1 , 2 , 234 ) = 234


eInd
Phi

eInd

description:	Euler's indicator (Totient Function)

syntax:	Phi ( x ) or eInd ( x )

domain:	Phi : Z -> N

example:	Phi ( 12 ) = 4

notes:	Euler's indicator is the number of prime numbers to the integer argument. Phi ( x ) = Phi ( - x ). Phi ( 1 ) = 1.

Phi( x ): Zm -> Z1 * Z2 ... Zm is a isomorphism, following this statement, the decomposition of any number into a product of prime numbers is unique. Euler has demonstrated this theorem and added that Phi ( x ) = x * ( 1 - 1 / p1 ) * ... * ( 1 - 1 / pn ), where p1 ... pn are prime number from the decomposition of x, taken once. Thus 12 = 2 ^ 2 * 3 and Phi ( 12 ) = 12 * ( 1 - 1/2 ) * ( 1 - 1/3 ) which is always an integer value and is equal to 4. Thus, there are 4 primes inferior and to 12.


Frac

description:	fraction part of a number

syntax:	Frac ( x )

domain:	Frac : R -> Z

example:	Frac ( 1.345 ) = 0.35 ( 0.345 )

notes:	Frac ( x ) = x - Trunc ( x )


Abs

description:	absolute value of a number

syntax:	Abs ( x )

domain:	Abs : R -> R

example:	Abs ( -2 ) = 2


Intg

description:	integer part of the number

syntax:	Intg ( x )

domain:	Intg : R -> Z

example:	Intg ( 2.1 ) = 2


Round

description:	rounds a number to the closest integer

syntax:	Round ( x )

domain:	Round : R -> Z

example:	Round ( -2.1 ) = -2


Trunc

description:	truncates the number to an integer

syntax:	Trunc ( x )

domain:	Trunc : R -> Z

example:	Trunc ( 2.1 ) = 2


log
Logten

description:	10 based logarithm of it's argument

syntax:	Logten ( x )

domain:	Logten : R+ -> R

example:	Logten ( 10 ^ 45 ) = 45


Logn

description:	calculates any based logarithm

syntax:	Logn ( base, x )

domain:	Logn : ( R+, R+ ) -> R

example:	Logn ( 2 , 8 ) = 3


Exp

description:	exponential of the argument

syntax:	Exp ( x )

domain:	Exp : R -> R

example:	Exp ( 3 ) = 20.09

notes:	raises E ( 2.72... ) in the power of x


ln
Ln / Log

description:	natural logarithm of the argument

syntax:	Ln ( x )

domain:	Ln : R+ -> R

example:	Ln ( E ) = 1


Ceil

description:	calculates the ceiling of the argument

syntax:	Ceil ( x )

domain:	Ceil : R -> R

example:	Ceil ( 2.1 ) = 3

Ceil ( -2.1 ) = -2


Floor

description:	calculates the floor of the argument

syntax:	Floor ( x )

domain:	Floor : R -> R

example:	Floor ( 2.1 ) = 2

Floor ( -2.1 ) = -3


Sqrt

description:	square root of an argument

syntax:	Sqrt ( x )

domain:	Sqrt : R+ -> R+

example:	Sqrt ( 4 ) = 2


Sqr

description:	raises the argument to it's second power

syntax:	Sqr ( x )

domain:	Sqr : R -> R

example:	Sqr ( 2 ) = 4


Random

description:	returns a random number <= to the argument

syntax:	Random ( x )

domain:	Random : R+ -> R+

example:	Random ( 8 ) = 4


Sin

description:	sine of the argument

syntax:	Sin ( x )

notes:	check the calculator mode before you perform any trigonometric calculation

90° = pi / 2 = 100 grad


Cos

description:	cosine of the argument

syntax:	Cos ( x )

notes:	check the calculator mode before you perform any trigonometric calculation

90° = pi / 2 = 100 grad


Tan

description:	tangent of the argument

syntax:	Tan ( x )

notes:	check the calculator mode before you perform any trigonometric calculation

90° = pi / 2 = 100 grad


Cot

description:	cotangent of the argument

syntax:	Cotan ( x )

notes:	check the calculator mode before you perform any trigonometric calculation

90° = pi / 2 = 100 grad


Sinh

description:	hyperbolic sine of the argument

syntax:	Sinh ( x )


Cosh

description:	hyperbolic cosine of the argument

syntax:	Cosh ( x )


Tanh

description:	hyperbolic tangent of the argument

syntax:	Tanh ( x )


coth
Cotanh

description:	hyperbolic cotangent of the argument

syntax:	Cotanh ( x )


Arcsin

description:	inverse sine of the argument

syntax:	Arcsin ( x )

notes:	check the calculator mode before you perform any trigonometric calculation


Arccos

description:	inverse cosine of the argument

syntax:	Arccos ( x )

notes:	check the calculator mode before you perform any trigonometric calculation


Arctan

description:	inverse tangent of the argument

syntax:	Arctan ( x )

notes:	check the calculator mode before you perform any trigonometric calculation


Arccot

description:	inverse cotangent of the argument

syntax:	Arccot ( x )

notes:	check the calculator mode before you perform any trigonometric calculation


Arcsinh

description:	inverse hyperbolic sine of the argument

syntax:	Arcsinh ( x )


Arccosh

description:	inverse hyperbolic cosine of the argument

syntax:	Arccosh ( x )


Arctanh

description:	inverse hyperbolic tangent of the argument

syntax:	Arctanh ( x )


Arccoth

description:	inverse hyperbolic cotangent of the argument

syntax:	Arccoth ( x )


Sec

description:	secant of the argument

syntax:	Sec ( x )

notes:	Sec ( x ) = 1 / Cos ( x )


Csc

description:	cosecant of the argument

syntax:	Csc ( x )

notes:	Csc ( x ) = 1 / Sin ( x )


Sech

description:	hyperbolic secant of the argument

syntax:	Sech ( x )

notes:	Sech ( x ) = 1 / Cosh ( x )


Csch

description:	hyperbolic cosecant of the argument

syntax:	Csch ( x )

notes:	Csch ( x ) = 1 / Sinh ( x )


Arcsec

description:	inverse secant of the argument

syntax:	Arcsec ( x )

notes:	Arcsec ( x ) = Arccos ( 1 /  x )


Arccsc

description:	inverse cosecant of the argument

syntax:	Arccsc ( x )

notes:	Arccsc ( x ) = Arcsin ( 1 /  x )


Arcsech

description:	inverse hyperbolic secant of the argument

syntax:	Arcsech ( x )

notes:	Arcsech ( x ) = Arccosh ( 1 /  x )


Arccsch

description:	inverse hyperbolic cosecant of the argument

syntax:	Arccsch ( x )

notes:	Arccsch ( x ) = Arcsinh ( 1 /  x )


prime, isprime
Prime

description:	latest prime number <= argument

syntax:	Prime ( x )

domain:	Prime : R -> N

example:	Prime ( 86 ) = 83

notes:	The routine of prime numbers calculation constructs a primes table while calculating higher prime numbers. It thus uses a powerful method to provide and immediate result if the prime number has already been calculated.

Use primec to get the number of primes inferior to a value.

Use primen to get the nth prime.

isprime ( x ) checks that x is a prime number (returns 1 if that is the case, 0 otherwise)

isprime ( x ) = prime ( x ) ? x


e

description:	raises a number into a 10 power

syntax:	x e y

domain:	e : R -> R

example:	3 e 4 = 30000


constants
E, Pi, G, Catalan

E 	= 2.71 ... 	and ln(E) = 1, Euler's number: 1+1+1/2!+1/3!+1/4!+...

Pi 	= 3.14 ... 	perimeter of half of the unit circle

Catalan 	= sum ( ( -1 ) ^ i / ( 2 * i + 1 ) ^ 2 , i = 0 ... infinity ) 	Catalan's constant , approximately 0.915965594...

G 	= limit ( sum ( 1 / i , i = 1 ... n ) - ln ( n ) , n = infinity )	Euler's Gamma Constant, approximately 0.5772156649..., used in trigonometric integrals

true	= 1	redifinition of 1

false	= 0	redifinition of 0


Mersienne

description:	finds the closest mersienne number inferior to the parameter (and < 2 ^ 32)

syntax:	Mersienne ( x )

domain:	Mersienne : [ 3,2 ^ 32 ] -> ( 3 , 7 , 31 , 127 , 8191 , 131071 , 524287 , 2147483647)

example:	Mersienne ( 145 ) = 127

notes:	when 2 ^ n - 1 is prime it is said to be a Mersienne prime.

M ( p ) = 2 ^ p - 1

P ( p ) = 2 ^ ( p - 1 ) * ( 2 ^ p - 1 ) is by the way a perfect number!

(taken from http://www.utm.edu/research/primes)


MersienneGen

description:	finds the closest mersienne generator inferior to the parameter (and < 32)

syntax:	MersienneGen ( x )

domain:	Mersienne : [ 2 , 32 ] -> ( 2 , 3 , 5 , 7 , 13 , 17 , 19 , 31)

example:	MersienneGen ( 8 ) = 7


MersGen

description:	finds the mersienne number for a mersienne generator

syntax:	MersGen ( x )

domain:	x must be a mersienne generator


GenMers

description:	finds the mersienne generator for a mersienne number

syntax:	GenMers ( x )

domain:	x must be a mersienne number


Perfect

description:	finds the closest inferior perfect number to the parameter

syntax:	Perfect ( x )

domain:	Perfect : R+ -> ( ... )

example:	Perfect ( 1231 ) = 496

notes:	a positive integer n is called a perfect number if it is equal to the sum of all of its positive divisors, excluding n itself.

6 = 3 * 2 * 1= 3 + 2 + 1

28 = 14 * 7 * 4 * 2 * 1 = 14 + 7 + 4 + 2 + 1

there is a direct relation to the mersienne primes M ( n ) := ( 2 ^ n - 1 ):

- k is an even perfect number if and only if it has the form 2 ^ ( n - 1 ) * ( 2 ^ n - 1 )

- if 2 ^ n - 1 is prime, then so is n

finally, it is not known whether or not there is an odd perfect number, but if there is one it is big

(taken from http://www.utm.edu/research/primes)


Average

description:	finds the average number between up to as many arguments as wanted

syntax:	Average ( x , ... , y )

domain:	Average: R -> R

example:	Average( 1 , 2 ) = 1.5


Beta

description:	computes Euler's Beta function

syntax:	Beta( a , b [ , dt ] )

a:	lower bound

b:	upper bound

dt: 	optional step, default is 0.01

notes: 	check the gamma function for more details:

The Beta function is a direct definition from the calculation of the product of two Gamma functions which is itself a double integral, note that for negative values the integral has no sense and Beta of negative values is a pure definition from the Gamma function.


PrimeC

description:	returns the number of primes inferior to it's argument

syntax:	Primec ( x )

domain:	R+ -> Z

notes:	1 is considered as a prime and the argument itself is included in the count if it is a prime number. Check the prime.  primen and phi functions.


PrimeN / ithPrime

description:	returns the nth prime

syntax:	PrimeN ( n ) or ithPrime ( n )

domain:	Z  -> Z

notes:	1 is considered as a prime, so primen ( 1 ) will return 1 and not 2. Check the prime,  primec and phi functions.


binomial
Binom

description:	binomial coefficients

syntax:	Binom ( n , j )

domain:	R -> R (with restrictions of Gamma function)

notes:	Binom ( n , j ) := n ! / ( j ! ( n - j ) ! )


mul & sum
Mul, Sum

description:	product and summation of a series of numbers

syntax:	Mul ( x , ... , y )

Sum( x , ... , y )


Harmonic

description:	harmonic function

harmonic ( n ) = sum( 1 / i , i = 1... n) = Psi ( n + 1 ) + gamma

syntax:	harmonic ( n )

examples:	harmonic ( 1 ) = 1

harmonic ( 2 ) = 1.500000000


Pochhammer

description:	general pochhammer function

pochhammer ( x , n ) = x * ( x + 1 ) * ... * ( x + n - 1 )

syntax:	pochhammer ( x , n )

examples:	pochhammer ( 5 , 3 ) = 210


Sigma, Tau

description:	sum of divisors

tau ( n ) - the sum of the positive divisors of n

sigma ( n , k ) - the sum of the k-th power of positive divisors of n

syntax:	tau ( n )

sigma ( n , k )

examples:	tau ( 9 ) = 13

tau ( 100 ) = 217

sigma ( 100 , 0 ) = 9


Integral Approximations (student)

description:	approximate a function's integral using quadrature functions

trapezoid (order 2 - level 2)

simpson (order 4 - level 3)

newton (order 4 - level 4)

boole (order 6 - level 5)

ordersix (order 6 - level 6)

weddle (order 8 - level 7)

syntax:	method ( function , variable , a , b [ , step ] )

function: 	any valid function

variable: 	any valid variable

a: 	lower bound

b: 	upper bound

step: 	optional interval division, default is 2048

examples:	Simpson:	simpson ( log ( x ^ 3 ) , x , 1 , 10 , 64 ) = 42.0775519815819 (5 decimals correct)

Weddle:	weddle ( log ( x ^ 3 ) , x , 1 , 10 , 64 ) = 42.0775527898212 (12 decimals correct)

Gauss:	int ( log ( x ^ 3 ) , x , 1 , 10 ) = 42.0775527898214 (all decimal correct)

I am not concurrencing Maple's heavy symbolic analysis:)

Maple:	evalf ( int ( log ( x ^ 3 ) , x = 1...10 ) ) = 42.0775527898214

theory:	The idea is to approximate the integral of a continuous or a discontinuous function with reasonable limits at the discontinuous points for a given interval [a,b]. The function trapezoid computes a numerical approximation to an integral using the Trapezoidal rule (order 2 quadrature formula of 2 levels). The quadrature functions are called Newton-Cotes formulas. Thus, in general, a quadrature formula is given by:

(where c -s are quadrature formula nodes and b -s are quadrature formula weights) and the quadrature formula is of order p if it is exact for all polynomials of degree p-1. Using this and a couple of other theorems that you may find in the Ernst Hairer's "Analyse Numérique" (available on the Internet at http://www.unige.ch)  weights are found for given nodes. A node is defined by dividing elementary intervals into s parts.

The simpson's approximation for the integral of a given function f(x) on an elementary interval [ x , x + h ] will be given by:  (h/6)*(f(x)+4*f(x+h/2)+f(x+h)). The Expression Calculator will use a default number of elementary intervals of 2048 if you don't specify any other value. It will divide the interval [a,b] into N elementary intervals and use a quadrature formula (here of Simpson) to approximate the integral.

Here is the table that the Expression Calculator uses for the said six quadrature formulas:

name	s 	p	weights

trapezoid	2	2	1/2	1/2

Simpson	3	4	1/6	4/6	1/6

Newton	4	4	1/8	3/8	3/8	1/8

Boole	5	6	7/90	32/90	12/90	32/90	7/90

OrderSix	6	6	19/288	75/288	50/288	50/288	75/288	19/288

Weddle	7	8	41/840	216/840	27/840	272/840	27/840	216/840	41/840

see: gaussian integrals


Integral Approximations (exact)

description:	approximate a function's integral using Gauss function

syntax:	int( function , variable , a , b [ , tol ] ) (you can use Gauss instead of Int)

function:	any valid function

variable:	any valid variable

a:	lower bound

b:	upper bound

tol:	optional integral tolerance (<1), default is 0, means will calculate till a stable result is found

examples:	int( x ^ 2 , x , 1 , 2 ) = 2.333... (all decimals correct)

Gauss integration never calculates the function at it's integral bounds, for example, the famous (-) gamma integral:

int ( log ( log ( 1 / x ) ) , x , 0 , 1 ) = -0.577215664901533 (Expression Calculator, all decimals correct)

evalf ( int ( log ( log ( 1 / x ) ) , x = 0..1 ) ) =  -0.5772156649 (Maple)

as you may see this function tends to infinity in x = 1 and has virtually no convergent values that could be used in points -> x = 1, this is where Gauss has it's best application

theory:	Gauss integrals approximations are the best before the symbolic analysis of software like Maple and Mathematica, which use very advanced symbolic techniques to represent the integrals and then evaluate expressions to provide an exact integral value or a very high precision. The Expression Calculator is no rival to this software. It does Integral approximations with Gauss quadrature method combined with a rather recent (1980s) technique developed at the University of Geneva. The value of integrals is an approximation, even if in most cases exact results for all decimals shown are found.

Expression Calculator uses the Tegral embedded quadrature formulas method. The major idea is to approximate the functions' integrals with an order 30 quadrature formula, which is calculated using Legendre's orthogonal polynomials. Two embedded quadrature formulas are extracted from the order 30, one of order 14 and another of order 6. All formulas are symmetric. The integral for the elementary interval is calculated from the order 30 quadrature formula, the maximum errors committed during the calculation using the other two. Like this, and this is different from other Gauss integration methods, the program knows exactly the maximum error it makes and can check the tolerance for the integral result.

Gauss is calculated for an interval [a,b] without using the bounds. If the error committed satisfies the given tolerance, the integral's value is kept as final, else the interval is divided into two equal parts, Gauss integral is calculated again. In case the sum of abs(errors) does not match the tolerance, Tegral will look for the interval that has the worst error and divide it into two parts. So on till a tolerated value is reached.

The Enhancements to Tegral are made through the Epsilon Algorithm (followed by Square Aitken's Delta theory (1926)) which aims to find a faster parallel series that converges to the integral value. The Epsilon Algorithm is excellent, but huge matrix determinants are to be calculated. The Expression Calculator uses the discovery of P.Wynn in 1936 which makes all this as simple as a Pascal triangle. Details and demonstrations for the mathematical theories can be found in C.Berezinsky (1977) "Accélération de la Convergence en Analyse Numérique" Lecture Notes in Mathematics, Nr. 584, Springer-Verlag.


dilogarithm, dawson
Dilog, Dawson

description:	dilogarithm integral function / dawson integral function

dilog ( x ) =  int ( ln ( t ) / ( 1 - t ) , t , 1 , x );

dawson ( x ) =  exp ( - ( x ^ 2 ) ) * int ( exp ( t ^ 2 ) , t = 0 , x )

syntax:	dilog ( x )

dawson ( x )

example:	dilog ( 100 ) = -12.1924216690332 (all decimals correct)


Erf, Erfc

description:	erf - The Error Function

erfc - The Complementary Error Function and its Iterated Integrals

syntax:	erf ( x ) = 2 / sqrt( Pi ) * int ( ( exp ( - t ^ 2 ) , t , 0 , x );

erfc ( x ) = 1 - erf ( x ) = 1 - 2 / Pi ^ ( 1 / 2 ) * int ( ( exp ( - t ^ 2 ) , t , 0 , x );

erfc ( x , n ) : not calculated with the Expression Calculator (infinite bounds integral)

examples:	erf ( 3 ) = 0.999977909503001 (all decimals correct)


SI, Ci, Ssi, Shi, Chi

description:	trigonometric integrals

Si - The Sine Integral

Ci - The Cosine Integral

Ssi - The Shifted Sine Integral

Shi - The Hyperbolic Sine Integral

Chi - The Hyperbolic Cosine Integral

syntax:	Si ( x )   = int ( sin ( t ) / t , t = 0 ... x )

Ci ( x )   = gamma + ln ( x ) + int ( ( cos ( t ) - 1) / t , t = 0 ... x )

Ssi ( x )  = Si ( x ) - Pi / 2

Shi ( x )  = int ( sinh ( t ) / t , t = 0 ... x )

Chi ( x )  = gamma + ln ( x ) + int ( ( cosh ( t ) - 1) / t , t = 0 ... x )

examples:	Ci ( 1 ) = 0.337403922900968 (all decimals correct - Maple: 0.33740392290096813466)

Si ( 100.4 ) = 1.56093636714801 (9 decimals correct - Maple: 1.5609363672707462437)

notes:	integration results are worse for huge values of x because of the nature of the integral and the machine precision

(those who are interested in computer generated errors should start by reading Runge's explanation for functions interpolation)

plot of the Ci ( x ) function:


Fresnel Integrals

description:	FresnelC - The Fresnel Cosine Integral

FresnelS - The Fresnel Sine Integral

Fresnelf, Fresnelg - The Fresnel Auxiliary Functions

syntax:	FresnelC ( x ) =  int ( cos ( Pi / 2 * t ^ 2 ) , t = 0 ... x );

FresnelS ( x ) =  int ( sin ( Pi / 2 * t ^ 2 ) , t = 0 ... x );

FresnelF ( x ) = ( 1 / 2 - FresnelS ( x ) ) * cos ( Pi / 2 * x ^ 2 ) - ( 1 / 2 - FresnelC ( x ) ) * sin ( Pi / 2 * x ^ 2 )

FresnelG ( x ) = ( 1 / 2 - FresnelC ( x ) ) * cos( Pi / 2 * x ^ 2 ) - ( 1 / 2 - FresnelS ( x ) ) * sin ( Pi / 2 * x ^ 2 )

examples:	FresnelC ( 1 ) = 0.779893400374992 (all decimals correct)

notes:	integration may take years for huge numbers because of the trigonometric nature of fresnel integrals


Elliptic Integrals

description:	EllipticE - Incomplete and complete elliptic integrals of the second kind

EllipticCE - Complementary complete elliptic integral of the second kind

EllipticF - Incomplete elliptic integral of the first kind

EllipticK - Complete elliptic integral of the first kind

EllipticCK - Complementary complete elliptic integral of the first kind

syntax:	EllipticE ( k , z ) = int ( sqrt ( 1 - k ^ 2 * t ^ 2 ) / sqrt ( 1 - t ^ 2 ) , t = 0 ... z)

EllipticE ( k ) = EllipticE ( 1 , k )

EllipticCE ( k ) = EllipticE ( 1 , sqrt ( 1 - k ^ 2 ) )

EllipticF( k , z ) = int ( 1 / sqrt (1 - t ^ 2 ) / sqrt ( 1 - k ^ 2 * t ^ 2 ) , t = 0 ... z )

EllipticK ( k ) = EllipticF ( 1 , k )

EllipticCK ( k ) = EllipticF ( 1 , sqrt ( 1 - k ^ 2 ) )

examples:	EllipticF ( 0.3 , 0.2 ) = 0.201479590139123 (all decimals correct)

notes:	Gauss integral precision for elliptic integrals is set to 10 ^ -7


Fermat

description:	returns the nth Fermat number

the nth Fermat number is 2 ^ ( 2 ^ n ) + 1

returns the nth Fermat number for n <= 4

example:	Fermat ( 4 ) = 65537.00


assignment
=, ?, >, <

description:	x = y	:	assigns a number to a variable, returns y

x ? y	:	returns +1 if x = y and 0 otherwise

x > y	:	returns +1 if x > y and 0 otherwise

x < y	:	returns +1 if x < y and 0 otherwise

example:	you can use the = function inside an expression:

int ( x ^ 2 / 5 , x , a = 0 , b = 5 )

-> 8.33333333333333e+0000

a

-> 0

b

-> 5

see also: user defined functions


Frequently Asked Questions

- Why does anybody need a multithread calculator?

Hmmm... i am not answering political questions. (Yep, the answer is as stupid as the question).

- Does multithreading make the calculation more precise?

No it doesn't. (and check question 1).

- Is the source available?

Yes it is. The source of the multithread calculation object written in object pascal (Delphi 2.0) is available on the Expression Calculator's home page at http://www.vestris.com.

For using it in large software projects, please contact the author. The price of the complete Expression Calculator source is US$ 100.- and is available on demand. Of course you may download the source for free, but besides the appeal of your conscience, you should remember that Big Brother's watching you:)

- Are you trying to concurrence Maple? (a Maple team question ... )

- No. The major difference between a calculator and a mathematical system is that the later is capable of polynomial simplifications and various kinds of operations that allow to find exact results of the expressions. All the operations are performed symbolically and evaluated on demand. The Expression Calcualtor is designed to provide a numerical approach to common and uncommon functions, including complicated ones in the domain of possible. So don't try to evaluate integrals on functions like y=0 when rational and y=1 when not.

- Where can I learn stuff like Gaussian integrals or multithread programming?

- At the University of Geneva. Lot's of material is available on the internet at http://www.unige.ch, math section. For programming...well, you don't learn such things, and who said that computer science is an exact matter?


register the Expression Calculator
Register!

Register Now!

What is registration and why should you register?

For a year, Expression Calculator was freeware. This means you could use Expression Calculator without any considerations, it was just given away. As  the Expression Calculator has become a huge program and one of the best on the market today, taking a lot of time and work, Expression Calculator  has become Shareware. This is a general new policy for Expression Calculator  and is valable for ALL versions of the Expression Calculator , so using an older version of  the Expression Calculator does not give you the right to use it for free.

Shareware means that we have made the software available to you for free evaluation.  You are entitled to evaluate the software for up to 15 days without obligation to pay.  After 15 days, if you decide to keep the software, you must register your copy with us for a small fee of 25.- US$ for a single licence. Check this page for payement details.

As you register, you receive a new version of the Expression Calculator. The major difference between the registered and the unregistered versions is the ability to define user functions, use financial functions and plot 2D graphs.

Vestris Inc. policy is very different from the companies who think that the short term benefits are the aim to achieve. We are a group of University of Geneva and Lausanne's Institute of Technology students that write top quality software and also bring all users top quality free or shareware products. We have learned a lot writing programms for you, we trust you and feel that you, the end-user must first get responsible with the shareware pricipe, so don't hesitate to show us that you like what we are doing for you and encourage us to continue. You can do this by simply registering the Expression Calculator! The price you pay is infinitely small in comparison of the support you bring to those who feel that a small enthousiast group can accomplish great things.

The announcements list for the Expression Calculator  is open to ALL users, regardless that they have or have not registered. Neithertheless, there will be cheaper updates, special prices and particular conditions for the Expression Calculator and other Vestris Inc. software, including commercial programms that will be released in the future for users who have registered earlier.

The Expression Calculator has received a great response from the users on the Internet and Vestris Inc. is very happy with the support it has encoutered! We are open to all suggestions and comments. We thank you for your attention, and don't forget to register!

How can you register?

Daniel Doubrovkine

(the Expression Calculator author)


User Defined Functions

This feature is available in the registered version only.

Defining private functions based on the large amount of Expression Calculator's mathematical inventory is extremely easy. You can call the user defined functions window by pressing F2 on the edit box or by calling the "User Defined Functions" command from the functions menu. You may not change the dozen of the predefined functions of the Expression Calculator, they are there to show the example of defining user functions. The table should be filled as follows (lines are added automatically when needed): the functions name, the functions variables and the function itself. You may as well define constants using the user defined functions.

function name:	a simple name that does not contain numbers or special characters

function variables:	variables defined as locals (parameters) for the function

function itself:	the expression to be calculated

example:	summ	xyz	x + y + z

defines a function "summ" is defined with three parameters x, y and z and performs a summation of x, y and z.

example:	income	25

defines a constant "income" of 25

The user functions definition does not analyze the expressions, they are evaluated during the execution only. A name redefinition overwrites the previous choices.

You may Update the changes, Reset the user defined functions (clear all the user defined functions), Cancel the current changes and remove a single user defined function. The user defined functions are kept in the local registry and are available during the next session of the Expression Calculator. Saving the calculations or loading them saves and updates the user functions respectively.


how to register
Register!

How can you register?

S.T.I. uses Kagi services for software registration which is very convenient for both the group and the registering users. The price for a single user licence for the Expression Calculator is 25.- US$. Simply launch the Register program from the main menu of the Expression Calculator - Register command and follow instructions on the screen. Kagi accepts cash, checks, money orders, VISA, MasterCard, American Express and First Virtual Payements. It can also issue invoices. Detailed help is available from the registration program.

Go to http://www.vestris.com, there might be a special online offer!

You may register electronically via the internet, without sending e-mail using the Kagi Online secure payment system. Check the register link at http://www.vestris.com or one of the mirrors.

Why should you register?

If you live in Switzerland or prefer to make a direct bank transfer, send a check or the cash amount to the author, please send it to:

Vestris Inc. - Daniel Doubrovkine

25, rue Jean-Violette

1205 Geneva, Switzerland

tel & fax: 41 (0) 22 329 03 06

e-mail: dblock@vestris.com / doubrov5@cuimail.unige.ch

note: Register for Windows program is (c) Grzegorz (Greg) Kochaniak


What's new

What's new?

 version 2.0 of the Expression Calculator has been rewritten using a powerful native multithread support of 32 bit systems such as Windows NT and ... well, still a _multithread_ support ... Windows 95.

the version 2.01 has a faster prime generation algorithm, speeding up 2.5 time approx the previous versions' calculations and eating 3 times less memory

the version 2.3 has the Gauss functions integration capability that allows an impressive list of predefined integrals

(version 2.02)

- the following functions will now accept up to 255 parameters: max, min, gcd, lcm

- max, min, gcd, lcm, gamma and logn will now work correctly as their _positive_ versions

- added average function

(version 2.03/2.04/2.05/2.06)

- faster calculation interrupt routine using native Win NT / 95 thread support instead of pseudo single task interrupt requests (you may now interrupt more than one calculation thread at the same time...you'll really see the difference in the Expression Calculator response with a slow machine)

- added suspend and resume threads routine (right button pops up the menu on the result grid)

- added command line parameters for startup (small, medium)

- added system information at the initialization and to the about box, providing processor(s), operating system, computer name and memory information

- added the help speed button

- added sleep delay at mutithread primes generator at second instance, speeds up main primes generator thread dramatically as prime threads are added

(version 2.1)

- corrected a severe bug in the prime generator

- corrected a bug in functions accepting more than 2 parameters, up to as many arguments as wanted can be specified for average, max, min, fcd and lcm

- added primeC, primeN

- added Euler's beta function

- added Binomial function

(version 2.11/2.12)

- added three functions (accessible from the menu of the calculation results grid by pressing the right mouse button), (special section for first two):

 - clear the primes' table, which resets all primes calculations that have been performed and frees all used memory

- copy the calculated primes to clipboard, copies the calculated primes to clipboard and delimits them by commas; this function is pretty slow and is a task that you cannot yet cancel

- reset the expression calculator

- corrected the pushbutton bug with the Arc and the Not buttons which could not be both down at the same time

- primes are cleared when the AC button is pressed or the Reset item in the grid menu chosen

- the result grid returns truncated values (with non-truncated values if different)

- the Expression Calculator will start in the last used mode (scientific / small / medium). Registry is used to store this information and it is user private.

(version 2.2)

- Expression Calculator can now be resized freely, buttons and panels follow during resizing, shape is kept at every restart. Registry is used to store this information and it is user private.

- The Expression Calculator will be set to the position and form of a previous session unless "small", "medium" or "scientific" parameter specified

(version 2.21)

- corrected last line highlight (when the last line in the grid is selected, the text copied to the entry box is also hightlighted)

- last operation selection has changed, it will scroll through the calculations performed (DOSKEY style) instead of simply copying the last operation a thousand times

- standard Windows copy (Ctrl-C), cut (Ctrl-X & Shift-Del) and paste (Ctrl-V & Shift Ins) functions do work in the edit box

- untruncated possible results are bigger (up to ~2^120 is shown in normal more instead of the X*10^style)

- when you press the first column (column with line numbers) on the grid, the result (not the expression) is copied to the clipboard

- you can now minimize the Expression Calculator

(version 2.22/2.23/2.24/2.25)

- corrected a dramatic lack of precision in the gamma, beta and factor functions for values over 70, the possible factorial, gamma and beta limits have been taken down to 1508!, but the results are precise for all of the values

- corrected value output for the X*10^ style for huge numbers

- you may start a fractional number with a point directly, 0.14322 may be written .14322

- corrected precision for very small negative values (47886.5-3323.4-6136.6-5547.6-14783.3-6958.8-1038.4-10098.4 did not give exactly 0)

- corrected precise result for negative values

- the initialization screen and some other bitmaps are full 256 color when using 256 color screen mode

- hexadecimal and octal modes work for negative numbers

- new parameter added to the Expression Calculator launch: "notitle" will not show the initialization bitmap when loading the Expression Calculator

- corrected the eInd (Phi) function, it will not affect the prime function any longer and will work correctly

- Expression Calculator will never start out of screen bounds any longer

- Init screen moved to front as the Expression Calculator initializes

(version 2.26/2.27)

- added code to avoid multithread concurrence bug under Windows NT 4.0, which caused the creation of unsuspendable and uninterruptable tasks during processor overload

- clicking on a pushed hex, bin, oct or rad button will reset the deg mode

- fixed resize problems, when the calculator is resized to the edge of the screen this has no effect on the opposite corner of the calculator

(version 2.3)

- the Expression Calculator has become really impressive, it is going shareware, please register!

- corrected Euler's indice: returns correct value for eInd(1) = 1

- removed new function for integral evaluation

- int function changed to intg because of the equivalent integral name

- linked the log function to ln for similarity with Maple and Mathematica, the new ten based logarithm is logten

- default mode is Radians for compatibility for default trigonometric function in Maple and Mathematica

- added trapezoid, simpson, newton, boole, ordersix, weddle integration approximation methods

- added Gauss integration method using Ernst Hairer's three level quadrature method

- added sum, mul

- added euler's constant

- added harmonic function

- added sigma(n,p), tau(n): the sum of the positive divisors of n in power p.

- added dilog(x): dilogarithm

- added Si - The Sine Integral

- added Ci - The Cosine Integral

- added Ssi - The Shifted Sine Integral

- added Shi - The Hyperbolic Sine Integral

- added Chi - The Hyperbolic Cosine Integral

- added Erf - The Error Function

- added Erfc - The Complementary Error Function and its Iterated Integrals

- added FresnelC - The Fresnel Cosine Integral

- added FresnelS - The Fresnel Sine Integral

- added FresnelF, FresnelG - The Fresnel Auxiliary Functions

- added EllipticE - Incomplete and complete elliptic integrals of the second kind

- added EllipticCE - Complementary complete elliptic integral of the second kind

- added EllipticF - Incomplete elliptic integral of the first kind

- added EllipticK - Complete elliptic integral of the first kind

- added EllipticCK - Complementary complete elliptic integral of the first kind

- added general Pochhammer function

- added Catalan's constant

- added Copy menu functions

- grouped tasks menu functions

- added Load and Save calculation grid + variables (full state save) functions

- error message '")" expected' has been replaced by function: too many parameters when this is the case

- beta function third step parameter is now optional

- added Fermat function that returns the first four fermat numbers

- added assignement = function

(version 2.31)

- implemented Epsilon Algorithm (explonential tables generation of delta^2 Aitken algorithm using P.Wynn's parallel series convergence discoveries of 1936) for Gauss Integrals

- added user defined functions (registered version only)

- added the ability to define named constants through the user defined functions

- saving the current state will save the user defined functions too

- corrected sum function

(version 2.32)

- the task counter has been changed for a progress bar

- added moebius / mu function

- added dawson integral function

- added true / false constants definitions

- added safeprime function

- user defined functions window keeps the position and fixed functions are grayed

- added isprime function

- added ithprime function equivalent for primeN

- added quot and rem functions for integer division

- added ?, >, < equality test functions

- added omitted sign for parenthesis multiplication possibility: ( 2 + 2 )( 1 - 5 ) = 4 * -4 = -16

- modified the - and + sign attachment for numbers and variables as used in other mathematical software: - 2 ^ 2 means - ( 2 ^ 2 ) now and not ( - 2 ) ^ 2

- added possibility to align multiple additive signs: - + - - 2 = - + + 2 = - + 2 = - 2

- added omitted sign for variables multiplication possibility: 2a = 2 * a

- added direct mode calculation option

- added 2D plot function (registered version only)

- added a series of financial functions (registered version only): sln, syd, cterm, term, pmt, rate, pv, npv, fv, db, ddb, irate, nper, paymt, ppaymt, ipaymt, pval, fval

(version 2.4)

- added cool buttons and corrected resize bugs

(version 2.41 and 2.42)

- added zplot (3D plot)

- space and alt+space show menus

- corrected button flicker


Moebius / Mu

description:	Moebius function

Mu ( x ) is 1  if  x  is a product of an even number of distinct primes,  - 1  if it is a product of an odd number of primes, and  0  if it has a multiple prime factor.

syntax:	Mu ( x )

domain:	Mu: N -> { -1 ,  0 ,  1 }

example:	Mu ( 1 ) = 1

Mu ( 2 ) = - 1

Mu ( 3 ) = - 1


Safeprime

description:	compute the smallest safe prime that is greater than x, a number p such that p is prime and ( p - 1 ) / 2 is prime too

syntax:	SafePrime ( x )

example:	SafePrime( 12 ) = 23